/*
*************************** C SOURCE FILE ************************************

project   : General Template
filename  : IO68K.C
version   : 2
date      : August 03, 2010

******************************************************************************

Copyright (c) 2003, P.K. van der Vlugt
All rights reserved.

******************************************************************************

VERSION HISTORY:
----------------------------
Version      : 1
Date         : August 02, 2010
Revised by   : P.K. van der Vlugt
Description  : Original version.

Version      : 2
Date         : August 03, 2010
Revised by   : P.K. van der Vlugt
Description  : * Changed input sampling time to 50 msec.
               * Added support for different CAN physical layers.
               * Added activation of the reference output.

******************************************************************************
*/

#define _IO68K_C_SRC

/****************************************************************************/
/**                                                                        **/
/**                             MODULES USED                               **/
/**                                                                        **/
/****************************************************************************/

#include "io68k.h"

/****************************************************************************/
/**                                                                        **/
/**                        DEFINITIONS AND MACROS                          **/
/**                                                                        **/
/****************************************************************************/

#define SW      *(int8u*)0xe001
#define LED     *(int8u*)0xe003
#define SLIDER  *(int8u*)0xe005
#define BAR     *(int8u*)0xe007
#define DIGIT0  *(int8u*)0xe011
#define DIGIT1  *(int8u*)0xe013
#define DIGIT2  *(int8u*)0xe015
#define DIGIT3  *(int8u*)0xe017

/****************************************************************************/
/**                                                                        **/
/**                        TYPEDEFS AND STRUCTURES                         **/
/**                                                                        **/
/****************************************************************************/


/****************************************************************************/
/**                                                                        **/
/**                      PROTOTYPES OF LOCAL FUNCTIONS                     **/
/**                                                                        **/
/****************************************************************************/

/****************************************************************************/
static void bin2Bcd (int16u bin);
/****************************************************************************/
/*
 Description: Compute 4-digit BCD from decimal number 0 - 9999 and store
 BCD numbers in the array named BcdArray.Interrupt should be disable before
 calling this function.
 Parameters: bin = 0 - 9999 ; decimal number to convert to 4-digit BCD
 Returns: None.
 Warning: This function does not check correctness of parameters.
*/

/****************************************************************************/
static int8u bcd2Segment (int8u bcd, int8u * segment);
/****************************************************************************/
/*
 Description: Convert 1 digit of BCD value to 1 digit of 7-segment display.
 Interrupt should be disable before calling this function.
 Parameters: bcd = 0 - 9 ; 1 digit of BCD value
             segment is an array of 10 elements storing segment BCD numbers.
 Returns: Segment of 7-segment display for BCD value.
 Warning: This function does not check correctness of parameters.
*/




/****************************************************************************/
/**                                                                        **/
/**                           EXPORTED VARIABLES                           **/
/**                                                                        **/
/****************************************************************************/



/****************************************************************************/
/**                                                                        **/
/**                            GLOBAL VARIABLES                            **/
/**                                                                        **/
/****************************************************************************/

/*********** 7-segment table **********/
static const int8u SegmentTable[10] = {0x3f,0x06,0x5b,0x4f,0x66,
                                       0x6d,0x7d,0x07,0x7f,0x6f};

static int8u BcdArray[4];

/****************************************************************************/
/**                                                                        **/
/**                           EXPORTED FUNCTIONS                           **/
/**                                                                        **/
/****************************************************************************/

/****************************************************************************/
int8u ReadSwAll (void)
/****************************************************************************/
{
 int8u swAll;
    swAll = SW;
    return swAll;
}

/****************************************************************************/
int8u ReadSwN (int8u n)
/****************************************************************************/
{
 int8u swN;
   if ( n > 7 )
   {
      swN = 0xff;
   }
   else
   {
      swN = SW & (0x01 << n);
      if( swN != 0 )
      {
         swN = 0x01;
      }
   }
   return swN;
}

/****************************************************************************/
int8u ReadLedAll (void)
/****************************************************************************/
{
 int8u ledAll;
   ledAll = LED;
   return ledAll;
}

/****************************************************************************/
int8u ReadLedN (int8u n)
/****************************************************************************/
{
 int8u ledN;
   if( n > 7)
   {
      ledN = 0xff;
   }
   else
   {
      ledN = LED & (0x01 << n);
      if( ledN != 0 )
      {
         ledN = 0x01;
      }
   }
   return ledN;
}

/****************************************************************************/
void WriteLedAll (int8u v)
/****************************************************************************/
{
   LED = v;
   return;
}

/****************************************************************************/
int8u WriteLedN (int8u n , int8u v)
/****************************************************************************/
{
 int8u ledN, err;
   if( n > 7)
   {
      err = ERR_N;
   }
   else if( v > 1 )
   {
      err = ERR_V;
   }
   else
   {
      if( v == 1 )
      {
         LED = LED | (0x01 << n);
      }
      else
      {
         LED = LED & (~(0x01 << n));
      }
      err = NO_ERR;
   }
   return err;
}

/****************************************************************************/
int8u ReadSlider (void)
/****************************************************************************/
{
 int8u dat;
   dat = SLIDER;
   return dat;
}


/****************************************************************************/
void WriteBar (int8u d)
/****************************************************************************/
{
   BAR = d;
   return;
}


/****************************************************************************/
int8u WriteDigitN (int8u n , int8u d)
/****************************************************************************/
{
 int8u err;
   if( n > 3 )
   {
      err = ERR_N;
   }
   else if( d > 9 )
   {
      err = ERR_D;
   }
   else
   {
      if( n == 0 )
      {
         DIGIT0 = (DIGIT0 & 0x80) | bcd2Segment (d, SegmentTable );
      }
      else if( n == 1)
      {
         DIGIT1 = (DIGIT1 & 0x80) | bcd2Segment (d, SegmentTable );
      }
      else if( n == 2)
      {
         DIGIT2 = (DIGIT2 & 0x80) | bcd2Segment (d, SegmentTable );
      }
      else
      {
         DIGIT3 = (DIGIT3 & 0x80) | bcd2Segment (d, SegmentTable );
      }
      err = NO_ERR;
   }
   return err;
}

/****************************************************************************/
int8u WriteDigitAll (int16u d)
/****************************************************************************/
{
 int8u i, err;
   if( d > 9999 )
   {
      err = ERR_D;
   }
   else
   {
      bin2Bcd(d);
      for( i = 0; i < 4; i++)
      {
          WriteDigitN ( i, BcdArray[i]);
      }
      err = NO_ERR;
   }
   return err;
}

/****************************************************************************/
int8u WriteDigitPointN (int8u n, int8u v)
/****************************************************************************/
{
 int8u err;
   if( n > 3)
   {
      err = ERR_N;
   }
   else if( v > 1 )
   {
      err = ERR_V;
   }
   else
   {
      if( v == 1 )
      {
         if( n == 0 )
         {
            DIGIT0 = DIGIT0 | 0x80 ;
         }
         else if( n == 1)
        {
            DIGIT1 = DIGIT1 | 0x80 ;
        }
        else if( n == 2)
        {
            DIGIT2 = DIGIT2 | 0x80 ;
        }
        else
        {
            DIGIT3 = DIGIT3 | 0x80 ;
        }
      }
      else
      {
         if( n == 0 )
         {
            DIGIT0 = DIGIT0 & 0x7f ;
         }
         else if( n == 1)
        {
            DIGIT1 = DIGIT1 & 0x7f ;
        }
        else if( n == 2)
        {
            DIGIT2 = DIGIT2 & 0x7f ;
        }
        else
        {
            DIGIT3 = DIGIT3 & 0x7f ;
        }
      }
      err = NO_ERR;
   }
   return err;
}


/****************************************************************************/
/**                                                                        **/
/**                             LOCAL FUNCTIONS                            **/
/**                                                                        **/
/****************************************************************************/

/****************************************************************************/
static void bin2Bcd (int16u bin)
/****************************************************************************/
{
 int8s i;
   for(i = 3; i >= 0; i--)
   {
      BcdArray[i] = (int8u)( bin % 10 );
      bin = bin / 10;
   }
   return;
}

/****************************************************************************/
static int8u bcd2Segment (int8u bcd, int8u * segment)
/****************************************************************************/
{
 int8u sm;
   sm = segment[bcd];
   return sm;
}



/****************************************************************************/


/****************************************************************************/
/**                                                                        **/
/**                                 EOF                                    **/
/**                                                                        **/
/****************************************************************************/